{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "import subprocess\n",
        "import sys\n",
        "import os\n",
        "from typing import Dict, List, Any, Optional, Union\n",
        "import json\n",
        "import asyncio\n",
        "from datetime import datetime\n",
        "import logging\n",
        "\n",
        "def install_packages():\n",
        "    \"\"\"Install required packages for the tutorial\"\"\"\n",
        "    packages = [\n",
        "        'mcp',\n",
        "        'google-generativeai',\n",
        "        'requests',\n",
        "        'beautifulsoup4',\n",
        "        'matplotlib',\n",
        "        'numpy',\n",
        "        'websockets',\n",
        "        'pydantic'\n",
        "    ]\n",
        "\n",
        "    for package in packages:\n",
        "        try:\n",
        "            subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", package])\n",
        "            print(f\"✅ Successfully installed {package}\")\n",
        "        except subprocess.CalledProcessError as e:\n",
        "            print(f\"❌ Failed to install {package}: {e}\")\n",
        "\n",
        "install_packages()"
      ],
      "metadata": {
        "id": "hr-QkKAcMHyg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import google.generativeai as genai\n",
        "import requests\n",
        "from bs4 import BeautifulSoup\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "from mcp import ClientSession, StdioServerParameters\n",
        "from mcp.client.stdio import stdio_client\n",
        "from mcp.types import TextContent, ImageContent, EmbeddedResource\n",
        "import mcp.types as types\n",
        "\n",
        "logging.basicConfig(level=logging.INFO)\n",
        "logger = logging.getLogger(__name__)"
      ],
      "metadata": {
        "id": "ssF3Zo-kMKeD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class MCPToolServer:\n",
        "    \"\"\"MCP Server that provides tools for the AI agent\"\"\"\n",
        "\n",
        "    def __init__(self):\n",
        "        self.tools = {\n",
        "            \"web_search\": {\n",
        "                \"name\": \"web_search\",\n",
        "                \"description\": \"Search the web for information\",\n",
        "                \"inputSchema\": {\n",
        "                    \"type\": \"object\",\n",
        "                    \"properties\": {\n",
        "                        \"query\": {\"type\": \"string\", \"description\": \"Search query\"}\n",
        "                    },\n",
        "                    \"required\": [\"query\"]\n",
        "                }\n",
        "            },\n",
        "            \"data_analysis\": {\n",
        "                \"name\": \"data_analysis\",\n",
        "                \"description\": \"Analyze data and create visualizations\",\n",
        "                \"inputSchema\": {\n",
        "                    \"type\": \"object\",\n",
        "                    \"properties\": {\n",
        "                        \"data_type\": {\"type\": \"string\", \"description\": \"Type of analysis\"},\n",
        "                        \"parameters\": {\"type\": \"object\", \"description\": \"Analysis parameters\"}\n",
        "                    },\n",
        "                    \"required\": [\"data_type\"]\n",
        "                }\n",
        "            },\n",
        "            \"code_execution\": {\n",
        "                \"name\": \"code_execution\",\n",
        "                \"description\": \"Execute or generate code\",\n",
        "                \"inputSchema\": {\n",
        "                    \"type\": \"object\",\n",
        "                    \"properties\": {\n",
        "                        \"language\": {\"type\": \"string\", \"description\": \"Programming language\"},\n",
        "                        \"task\": {\"type\": \"string\", \"description\": \"Code task description\"}\n",
        "                    },\n",
        "                    \"required\": [\"language\", \"task\"]\n",
        "                }\n",
        "            },\n",
        "            \"weather_info\": {\n",
        "                \"name\": \"weather_info\",\n",
        "                \"description\": \"Get weather information\",\n",
        "                \"inputSchema\": {\n",
        "                    \"type\": \"object\",\n",
        "                    \"properties\": {\n",
        "                        \"location\": {\"type\": \"string\", \"description\": \"Location for weather\"}\n",
        "                    },\n",
        "                    \"required\": [\"location\"]\n",
        "                }\n",
        "            }\n",
        "        }\n",
        "\n",
        "    async def list_tools(self) -> List[types.Tool]:\n",
        "        \"\"\"Return list of available tools\"\"\"\n",
        "        return [types.Tool(**tool) for tool in self.tools.values()]\n",
        "\n",
        "    async def call_tool(self, name: str, arguments: Dict[str, Any]) -> List[types.TextContent]:\n",
        "        \"\"\"Execute a tool and return results\"\"\"\n",
        "        if name == \"web_search\":\n",
        "            return await self._web_search(arguments.get(\"query\", \"\"))\n",
        "        elif name == \"data_analysis\":\n",
        "            return await self._data_analysis(arguments.get(\"data_type\", \"\"), arguments.get(\"parameters\", {}))\n",
        "        elif name == \"code_execution\":\n",
        "            return await self._code_execution(arguments.get(\"language\", \"\"), arguments.get(\"task\", \"\"))\n",
        "        elif name == \"weather_info\":\n",
        "            return await self._weather_info(arguments.get(\"location\", \"\"))\n",
        "        else:\n",
        "            return [types.TextContent(type=\"text\", text=f\"Unknown tool: {name}\")]\n",
        "\n",
        "    async def _web_search(self, query: str) -> List[types.TextContent]:\n",
        "        \"\"\"Perform web search\"\"\"\n",
        "        try:\n",
        "            search_url = f\"https://www.wikipedia.org/wiki/Special:Search?search={query.replace(' ', '%20')}\"\n",
        "            headers = {'User-Agent': 'Mozilla/5.0 (compatible; MCP Agent)'}\n",
        "\n",
        "            response = requests.get(search_url, headers=headers, timeout=10)\n",
        "            if response.status_code == 200:\n",
        "                soup = BeautifulSoup(response.content, 'html.parser')\n",
        "                paragraphs = soup.find_all('p')[:3]\n",
        "                content = \"\\n\".join([p.get_text().strip() for p in paragraphs if p.get_text().strip()])\n",
        "\n",
        "                result = f\"🔍 Web search results for '{query}':\\n\\n{content[:500]}...\"\n",
        "            else:\n",
        "                result = f\"❌ Web search failed with status: {response.status_code}\"\n",
        "\n",
        "        except Exception as e:\n",
        "            result = f\"❌ Web search error: {str(e)}\"\n",
        "\n",
        "        return [types.TextContent(type=\"text\", text=result)]\n",
        "\n",
        "    async def _data_analysis(self, data_type: str, parameters: Dict) -> List[types.TextContent]:\n",
        "        \"\"\"Perform data analysis\"\"\"\n",
        "        try:\n",
        "            if \"sine\" in data_type.lower() or \"wave\" in data_type.lower():\n",
        "                x = np.linspace(0, 4*np.pi, 100)\n",
        "                y = np.sin(x) + np.random.normal(0, 0.1, 100)\n",
        "                title = \"Sine Wave Analysis\"\n",
        "            else:\n",
        "                x = np.random.normal(0, 1, 100)\n",
        "                y = np.random.normal(0, 1, 100)\n",
        "                title = \"Random Data Analysis\"\n",
        "\n",
        "            plt.figure(figsize=(10, 6))\n",
        "            plt.scatter(x, y, alpha=0.6)\n",
        "            plt.title(f\"📊 {title}\")\n",
        "            plt.xlabel(\"X Values\")\n",
        "            plt.ylabel(\"Y Values\")\n",
        "            plt.grid(True, alpha=0.3)\n",
        "            plt.show()\n",
        "\n",
        "            stats = {\n",
        "                \"mean_x\": np.mean(x),\n",
        "                \"mean_y\": np.mean(y),\n",
        "                \"std_x\": np.std(x),\n",
        "                \"std_y\": np.std(y),\n",
        "                \"correlation\": np.corrcoef(x, y)[0,1]\n",
        "            }\n",
        "\n",
        "            result = f\"📊 Data Analysis Results:\\n\"\n",
        "            result += f\"Dataset: {title}\\n\"\n",
        "            result += f\"Sample size: {len(x)}\\n\"\n",
        "            result += f\"X - Mean: {stats['mean_x']:.3f}, Std: {stats['std_x']:.3f}\\n\"\n",
        "            result += f\"Y - Mean: {stats['mean_y']:.3f}, Std: {stats['std_y']:.3f}\\n\"\n",
        "            result += f\"Correlation: {stats['correlation']:.3f}\\n\"\n",
        "            result += f\"\\n📈 Visualization displayed above!\"\n",
        "\n",
        "        except Exception as e:\n",
        "            result = f\"❌ Data analysis error: {str(e)}\"\n",
        "\n",
        "        return [types.TextContent(type=\"text\", text=result)]\n",
        "\n",
        "    async def _code_execution(self, language: str, task: str) -> List[types.TextContent]:\n",
        "        \"\"\"Handle code generation/execution\"\"\"\n",
        "        try:\n",
        "            if language.lower() == \"python\":\n",
        "                if \"fibonacci\" in task.lower():\n",
        "                    code = '''def fibonacci(n):\n",
        "    \"\"\"Generate fibonacci sequence up to n terms\"\"\"\n",
        "    if n <= 0:\n",
        "        return []\n",
        "    elif n == 1:\n",
        "        return [0]\n",
        "    elif n == 2:\n",
        "        return [0, 1]\n",
        "\n",
        "    fib = [0, 1]\n",
        "    for i in range(2, n):\n",
        "        fib.append(fib[i-1] + fib[i-2])\n",
        "    return fib\n",
        "\n",
        "# Example usage\n",
        "print(\"First 10 fibonacci numbers:\", fibonacci(10))'''\n",
        "\n",
        "                elif \"sort\" in task.lower():\n",
        "                    code = '''def quicksort(arr):\n",
        "    \"\"\"Quick sort implementation\"\"\"\n",
        "    if len(arr) <= 1:\n",
        "        return arr\n",
        "    pivot = arr[len(arr) // 2]\n",
        "    left = [x for x in arr if x < pivot]\n",
        "    middle = [x for x in arr if x == pivot]\n",
        "    right = [x for x in arr if x > pivot]\n",
        "    return quicksort(left) + middle + quicksort(right)\n",
        "\n",
        "# Example usage\n",
        "data = [64, 34, 25, 12, 22, 11, 90]\n",
        "print(\"Original:\", data)\n",
        "print(\"Sorted:\", quicksort(data))'''\n",
        "\n",
        "                else:\n",
        "                    code = f'''# Python code for: {task}\n",
        "# This is a template - customize based on your specific needs\n",
        "\n",
        "def main():\n",
        "    \"\"\"Main function for {task}\"\"\"\n",
        "    print(\"Implementing: {task}\")\n",
        "    # Add your implementation here\n",
        "    pass\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    main()'''\n",
        "\n",
        "                result = f\"💻 Python Code for '{task}':\\n\\n```python\\n{code}\\n```\"\n",
        "\n",
        "                if \"fibonacci\" in task.lower():\n",
        "                    try:\n",
        "                        exec(code)\n",
        "                        result += \"\\n\\n✅ Code executed successfully!\"\n",
        "                    except Exception as exec_error:\n",
        "                        result += f\"\\n\\n⚠️ Execution note: {exec_error}\"\n",
        "\n",
        "            else:\n",
        "                result = f\"💻 Code template for {language}:\\n\\n\"\n",
        "                result += f\"// {task}\\n// Language: {language}\\n// Add your implementation here\"\n",
        "\n",
        "        except Exception as e:\n",
        "            result = f\"❌ Code generation error: {str(e)}\"\n",
        "\n",
        "        return [types.TextContent(type=\"text\", text=result)]\n",
        "\n",
        "    async def _weather_info(self, location: str) -> List[types.TextContent]:\n",
        "        \"\"\"Get weather information\"\"\"\n",
        "        weather_data = {\n",
        "            \"temperature\": np.random.randint(15, 30),\n",
        "            \"condition\": np.random.choice([\"Sunny\", \"Cloudy\", \"Rainy\", \"Partly Cloudy\"]),\n",
        "            \"humidity\": np.random.randint(40, 80),\n",
        "            \"wind_speed\": np.random.randint(5, 25)\n",
        "        }\n",
        "\n",
        "        result = f\"🌤️ Weather for {location}:\\n\"\n",
        "        result += f\"Temperature: {weather_data['temperature']}°C\\n\"\n",
        "        result += f\"Condition: {weather_data['condition']}\\n\"\n",
        "        result += f\"Humidity: {weather_data['humidity']}%\\n\"\n",
        "        result += f\"Wind Speed: {weather_data['wind_speed']} km/h\\n\"\n",
        "        result += f\"\\n📝 Note: This is simulated data. For real weather, use a weather API service.\"\n",
        "\n",
        "        return [types.TextContent(type=\"text\", text=result)]"
      ],
      "metadata": {
        "id": "bZsvA-8SMNJ9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class MCPAgent:\n",
        "    \"\"\"AI Agent using MCP (Model Context Protocol)\"\"\"\n",
        "\n",
        "    def __init__(self, gemini_api_key: Optional[str] = None):\n",
        "        self.gemini_api_key = gemini_api_key or self._get_api_key()\n",
        "        self.mcp_server = MCPToolServer()\n",
        "        self.conversation_history = []\n",
        "\n",
        "        if self.gemini_api_key:\n",
        "            genai.configure(api_key=self.gemini_api_key)\n",
        "            self.model = genai.GenerativeModel('gemini-1.5-flash')\n",
        "            print(\"✅ MCP Agent initialized with Gemini!\")\n",
        "        else:\n",
        "            self.model = None\n",
        "            print(\"⚠️ MCP Agent initialized without Gemini (limited functionality)\")\n",
        "\n",
        "    def _get_api_key(self) -> Optional[str]:\n",
        "        \"\"\"Get Gemini API key\"\"\"\n",
        "        api_key = os.environ.get('GEMINI_API_KEY')\n",
        "        if not api_key:\n",
        "            print(\"📝 Get your free API key from: https://makersuite.google.com/app/apikey\")\n",
        "            api_key = input(\"Enter your Gemini API key (or press Enter to skip): \").strip()\n",
        "        return api_key if api_key else None\n",
        "\n",
        "    async def process_request(self, user_input: str) -> str:\n",
        "        \"\"\"Process user request using MCP tools and Gemini\"\"\"\n",
        "        self.conversation_history.append({\"role\": \"user\", \"content\": user_input})\n",
        "\n",
        "        available_tools = await self.mcp_server.list_tools()\n",
        "        tool_descriptions = \"\\n\".join([f\"- {tool.name}: {tool.description}\" for tool in available_tools])\n",
        "\n",
        "        if self.model:\n",
        "            analysis_prompt = f\"\"\"\n",
        "            User request: \"{user_input}\"\n",
        "\n",
        "            Available MCP tools:\n",
        "            {tool_descriptions}\n",
        "\n",
        "            Should I use a tool for this request? If yes, specify:\n",
        "            1. Tool name (exact match)\n",
        "            2. Arguments as JSON\n",
        "\n",
        "            If no tool needed, respond with \"NO_TOOL\".\n",
        "\n",
        "            Format: TOOL_NAME|{{\"argument\": \"value\"}}\n",
        "            \"\"\"\n",
        "\n",
        "            analysis = self.model.generate_content(analysis_prompt).text.strip()\n",
        "\n",
        "            if analysis != \"NO_TOOL\" and \"|\" in analysis:\n",
        "                try:\n",
        "                    tool_name, args_json = analysis.split(\"|\", 1)\n",
        "                    tool_name = tool_name.strip()\n",
        "                    arguments = json.loads(args_json)\n",
        "\n",
        "                    tool_results = await self.mcp_server.call_tool(tool_name, arguments)\n",
        "                    tool_output = \"\\n\".join([content.text for content in tool_results])\n",
        "\n",
        "                    final_prompt = f\"\"\"\n",
        "                    User asked: \"{user_input}\"\n",
        "\n",
        "                    I used the {tool_name} tool and got this result:\n",
        "                    {tool_output}\n",
        "\n",
        "                    Please provide a helpful response that incorporates this information.\n",
        "                    \"\"\"\n",
        "\n",
        "                    response = self.model.generate_content(final_prompt).text\n",
        "\n",
        "                except Exception as e:\n",
        "                    response = f\"❌ Error using MCP tool: {str(e)}\\n\\nLet me help you directly instead.\\n\"\n",
        "                    response += self.model.generate_content(user_input).text\n",
        "            else:\n",
        "                response = self.model.generate_content(user_input).text\n",
        "        else:\n",
        "            response = f\"🤖 MCP Agent received: {user_input}\\n\"\n",
        "            response += \"Available tools: \" + \", \".join([tool.name for tool in available_tools])\n",
        "            response += \"\\n💡 Configure Gemini API for full functionality!\"\n",
        "\n",
        "        self.conversation_history.append({\"role\": \"assistant\", \"content\": response})\n",
        "        return response"
      ],
      "metadata": {
        "id": "i9dnQWbnMcfb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "async def run_mcp_demo():\n",
        "    \"\"\"Run comprehensive MCP Agent demo\"\"\"\n",
        "    print(\"🚀 MCP Agent Demo Starting!\")\n",
        "    print(\"=\" * 50)\n",
        "\n",
        "    agent = MCPAgent()\n",
        "\n",
        "    demo_queries = [\n",
        "        \"Search for information about machine learning\",\n",
        "        \"Create a data visualization with sine wave analysis\",\n",
        "        \"Write a Python function to calculate fibonacci numbers\",\n",
        "        \"What's the weather like in New York?\",\n",
        "        \"Explain how artificial intelligence works\"\n",
        "    ]\n",
        "\n",
        "    print(\"\\n🧪 Running MCP Tool Demonstrations:\")\n",
        "    print(\"-\" * 40)\n",
        "\n",
        "    for i, query in enumerate(demo_queries, 1):\n",
        "        print(f\"\\n📝 Query {i}: {query}\")\n",
        "        print(\"-\" * 30)\n",
        "\n",
        "        response = await agent.process_request(query)\n",
        "        print(response)\n",
        "\n",
        "        if i < len(demo_queries):\n",
        "            print(\"\\n⏳ Next demo in 3 seconds...\")\n",
        "            await asyncio.sleep(3)\n",
        "\n",
        "    print(\"\\n✅ MCP Demo completed!\")\n",
        "    return agent\n",
        "\n",
        "async def interactive_mcp_mode(agent: MCPAgent):\n",
        "    \"\"\"Interactive mode with MCP agent\"\"\"\n",
        "    print(\"\\n💬 Interactive MCP Mode!\")\n",
        "    print(\"Type 'quit' to exit, 'tools' to see available MCP tools\")\n",
        "\n",
        "    while True:\n",
        "        try:\n",
        "            user_input = input(\"\\n🗣️ You: \").strip()\n",
        "\n",
        "            if user_input.lower() == 'quit':\n",
        "                print(\"👋 Goodbye!\")\n",
        "                break\n",
        "            elif user_input.lower() == 'tools':\n",
        "                tools = await agent.mcp_server.list_tools()\n",
        "                print(\"\\n🛠️ Available MCP Tools:\")\n",
        "                for tool in tools:\n",
        "                    print(f\"  - {tool.name}: {tool.description}\")\n",
        "                continue\n",
        "            elif not user_input:\n",
        "                continue\n",
        "\n",
        "            response = await agent.process_request(user_input)\n",
        "            print(f\"\\n🤖 MCP Agent: {response}\")\n",
        "\n",
        "        except KeyboardInterrupt:\n",
        "            print(\"\\n👋 Goodbye!\")\n",
        "            break\n",
        "        except Exception as e:\n",
        "            print(f\"❌ Error: {str(e)}\")\n",
        "\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    print(\"🎯 Advanced AI Agent with MCP (Model Context Protocol)\")\n",
        "    print(\"Built for Google Colab with Gemini API integration\")\n",
        "    print(\"=\" * 60)\n",
        "\n",
        "    agent = asyncio.run(run_mcp_demo())\n",
        "\n",
        "    asyncio.run(interactive_mcp_mode(agent))\n",
        "\n",
        "    print(\"\\n📚 MCP Tutorial Complete!\")\n",
        "    print(\"\\n🔍 What you learned:\")\n",
        "    print(\"✅ How to implement MCP (Model Context Protocol) tools\")\n",
        "    print(\"✅ Tool registration and discovery\")\n",
        "    print(\"✅ Structured tool calling with arguments\")\n",
        "    print(\"✅ Integration between MCP tools and Gemini AI\")\n",
        "    print(\"✅ Async tool execution and response handling\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "b8nmQ_d-Ky7X",
        "outputId": "62558bd0-9a9b-4ea1-c0d2-da270d0cb356"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "🎯 Advanced AI Agent with MCP (Model Context Protocol)\n",
            "Built for Google Colab with Gemini API integration\n",
            "============================================================\n",
            "🚀 MCP Agent Demo Starting!\n",
            "==================================================\n",
            "✅ MCP Agent initialized with Gemini!\n",
            "\n",
            "🧪 Running MCP Tool Demonstrations:\n",
            "----------------------------------------\n",
            "\n",
            "📝 Query 1: Search for information about machine learning\n",
            "------------------------------\n",
            "Machine learning (ML) is a branch of artificial intelligence focused on creating algorithms that learn from data without explicit programming.  This means instead of being explicitly told how to perform a task, the algorithm identifies patterns and makes predictions based on the data it's trained on.  The search results highlight that these algorithms, often statistical in nature, aim to generalize their learning to new, unseen data.  Recent advancements in deep learning, a subfield of machine learning using neural networks, have significantly improved the performance of many ML approaches.  ML is used across a wide range of applications (the search results mention this, though the full list is cut off).  To learn more about specific applications or techniques, you might want to refine your search with more specific keywords, such as \"machine learning applications in healthcare\" or \"machine learning algorithms.\"\n",
            "\n",
            "\n",
            "⏳ Next demo in 3 seconds...\n",
            "\n",
            "📝 Query 2: Create a data visualization with sine wave analysis\n",
            "------------------------------\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The data analysis shows a weak negative correlation (-0.038) between the X and Y variables in your dataset.  This suggests there's very little linear relationship between them.  The means and standard deviations provide a sense of the data's central tendency and spread.  However, the key takeaway is the near-zero correlation, indicating that a simple linear model wouldn't be effective in predicting Y based on X.\n",
            "\n",
            "Since you mentioned \"sine wave analysis,\" I'm assuming you suspect a cyclical or periodic pattern in your data. A weak linear correlation doesn't rule this out.  To better understand if a sine wave is a suitable model, we need more information:\n",
            "\n",
            "* **The visualization itself:**  The `📈 Visualization displayed above!` is crucial.  Please provide the actual visualization (a chart or image).  This is essential to assess the presence of cyclical patterns.  Does the data appear to oscillate around a mean?  What's the approximate frequency of these oscillations?\n",
            "\n",
            "* **The data itself:** Accessing the raw data would allow for a more thorough analysis.  With the data, we can perform a Fourier Transform, which is specifically designed to decompose signals into their constituent frequencies, revealing if a sine wave (or multiple sine waves) are significant components.\n",
            "\n",
            "* **The context:** What kind of data is this?  Knowing the source and what X and Y represent can inform the interpretation.  For example, if X is time and Y is some physical measurement, a sine wave might be expected.\n",
            "\n",
            "\n",
            "In summary, while the initial analysis shows little linear correlation, the possibility of a sine wave relationship remains.  Providing the visualization and, ideally, the raw data will allow for a more conclusive sine wave analysis.\n",
            "\n",
            "\n",
            "⏳ Next demo in 3 seconds...\n",
            "\n",
            "📝 Query 3: Write a Python function to calculate fibonacci numbers\n",
            "------------------------------\n",
            "The code template you provided is incomplete.  It only shows a comment indicating a place to add code.  To calculate Fibonacci numbers in Python, you have several options. Here are a few examples, with explanations:\n",
            "\n",
            "**Method 1: Iterative Approach (Most Efficient)**\n",
            "\n",
            "This method uses a loop and is generally the most efficient way to calculate Fibonacci numbers, especially for larger values.\n",
            "\n",
            "```python\n",
            "def fibonacci_iterative(n):\n",
            "  \"\"\"\n",
            "  Calculates the nth Fibonacci number iteratively.\n",
            "\n",
            "  Args:\n",
            "    n: The index of the desired Fibonacci number (starting from 0).\n",
            "\n",
            "  Returns:\n",
            "    The nth Fibonacci number.  Returns 0 if n is negative.\n",
            "  \"\"\"\n",
            "  if n < 0:\n",
            "    return 0\n",
            "  elif n <= 1:\n",
            "    return n\n",
            "  else:\n",
            "    a, b = 0, 1\n",
            "    for _ in range(2, n + 1):\n",
            "      a, b = b, a + b\n",
            "    return b\n",
            "\n",
            "# Example usage\n",
            "print(fibonacci_iterative(0))  # Output: 0\n",
            "print(fibonacci_iterative(1))  # Output: 1\n",
            "print(fibonacci_iterative(5))  # Output: 5\n",
            "print(fibonacci_iterative(10)) # Output: 55\n",
            "```\n",
            "\n",
            "**Method 2: Recursive Approach (Simple but Inefficient)**\n",
            "\n",
            "This approach is conceptually simpler but can be very slow for larger values of `n` due to repeated calculations.\n",
            "\n",
            "```python\n",
            "def fibonacci_recursive(n):\n",
            "  \"\"\"\n",
            "  Calculates the nth Fibonacci number recursively.\n",
            "\n",
            "  Args:\n",
            "    n: The index of the desired Fibonacci number (starting from 0).\n",
            "\n",
            "  Returns:\n",
            "    The nth Fibonacci number. Returns 0 if n is negative.\n",
            "  \"\"\"\n",
            "  if n < 0:\n",
            "    return 0\n",
            "  elif n <= 1:\n",
            "    return n\n",
            "  else:\n",
            "    return fibonacci_recursive(n-1) + fibonacci_recursive(n-2)\n",
            "\n",
            "# Example usage (avoid large n with this method!)\n",
            "print(fibonacci_recursive(0))  # Output: 0\n",
            "print(fibonacci_recursive(1))  # Output: 1\n",
            "print(fibonacci_recursive(5))  # Output: 5\n",
            "#print(fibonacci_recursive(35)) # This will be very slow!\n",
            "```\n",
            "\n",
            "**Method 3: Using Dynamic Programming (Efficient Recursive)**\n",
            "\n",
            "This approach avoids redundant calculations by storing previously computed Fibonacci numbers.  It combines the simplicity of recursion with the efficiency of iteration.\n",
            "\n",
            "```python\n",
            "memo = {}  # Dictionary to store calculated Fibonacci numbers\n",
            "\n",
            "def fibonacci_dynamic(n):\n",
            "  \"\"\"\n",
            "  Calculates the nth Fibonacci number using dynamic programming.\n",
            "\n",
            "  Args:\n",
            "    n: The index of the desired Fibonacci number (starting from 0).\n",
            "\n",
            "  Returns:\n",
            "    The nth Fibonacci number. Returns 0 if n is negative.\n",
            "  \"\"\"\n",
            "  if n < 0:\n",
            "    return 0\n",
            "  elif n in memo:\n",
            "    return memo[n]\n",
            "  elif n <= 1:\n",
            "    return n\n",
            "  else:\n",
            "    result = fibonacci_dynamic(n-1) + fibonacci_dynamic(n-2)\n",
            "    memo[n] = result\n",
            "    return result\n",
            "\n",
            "# Example usage\n",
            "print(fibonacci_dynamic(0))  # Output: 0\n",
            "print(fibonacci_dynamic(1))  # Output: 1\n",
            "print(fibonacci_dynamic(5))  # Output: 5\n",
            "print(fibonacci_dynamic(35)) # This will be much faster than the purely recursive version\n",
            "```\n",
            "\n",
            "Remember to choose the method that best suits your needs.  For most cases, the iterative approach (`fibonacci_iterative`) is recommended for its efficiency.  The dynamic programming approach is a good compromise between readability and efficiency if you want to use recursion.  Avoid the purely recursive approach for large `n` values.  Replace the comment in your code template with one of these functions.\n",
            "\n",
            "\n",
            "⏳ Next demo in 3 seconds...\n",
            "\n",
            "📝 Query 4: What's the weather like in New York?\n",
            "------------------------------\n",
            "It's currently rainy in New York City with a temperature of 25°C (that's about 77°F).  The humidity is at 57%, and there's a fairly brisk wind blowing at 21 km/h.  So, remember to grab an umbrella and a light jacket if you're heading out!  Keep in mind that this is simulated weather data; for the most accurate forecast, please check a reliable weather app or website.\n",
            "\n",
            "\n",
            "⏳ Next demo in 3 seconds...\n",
            "\n",
            "📝 Query 5: Explain how artificial intelligence works\n",
            "------------------------------\n",
            "I'm sorry, I can't explain how artificial intelligence works using the TOOL_NAME tool because I don't know what that tool is.  My knowledge of tools is limited to those I've been trained on.\n",
            "\n",
            "However, I can still explain how AI works in general terms.  At a high level, AI involves creating systems that can perform tasks that typically require human intelligence. This is achieved through various techniques, including:\n",
            "\n",
            "* **Machine Learning (ML):**  This is a core component of many AI systems.  ML algorithms allow computers to learn from data without explicit programming.  They identify patterns and relationships in data to make predictions or decisions.  Different types of ML include supervised learning (learning from labeled data), unsupervised learning (finding patterns in unlabeled data), and reinforcement learning (learning through trial and error).\n",
            "\n",
            "* **Deep Learning (DL):** A subfield of ML that uses artificial neural networks with multiple layers (hence \"deep\").  These networks are inspired by the structure and function of the human brain and are particularly good at processing complex data like images, audio, and text.\n",
            "\n",
            "* **Natural Language Processing (NLP):**  This focuses on enabling computers to understand, interpret, and generate human language.  NLP is used in applications like chatbots, machine translation, and sentiment analysis.\n",
            "\n",
            "* **Computer Vision:** This allows computers to \"see\" and interpret images and videos.  It's used in applications like self-driving cars, facial recognition, and medical image analysis.\n",
            "\n",
            "* **Robotics:** This involves creating intelligent robots that can interact with the physical world.  AI plays a crucial role in enabling robots to perceive their environment, make decisions, and perform actions.\n",
            "\n",
            "\n",
            "It's important to note that AI is a broad field, and these are just some of the key techniques used.  The specific methods employed depend on the particular application.  If you have a more specific question about a particular type of AI, I'll do my best to answer it.\n",
            "\n",
            "\n",
            "✅ MCP Demo completed!\n",
            "\n",
            "💬 Interactive MCP Mode!\n",
            "Type 'quit' to exit, 'tools' to see available MCP tools\n",
            "\n",
            "🗣️ You: tools\n",
            "\n",
            "🛠️ Available MCP Tools:\n",
            "  - web_search: Search the web for information\n",
            "  - data_analysis: Analyze data and create visualizations\n",
            "  - code_execution: Execute or generate code\n",
            "  - weather_info: Get weather information\n",
            "\n",
            "🗣️ You: exit\n",
            "\n",
            "🤖 MCP Agent: Okay, goodbye!\n",
            "\n",
            "\n",
            "🗣️ You: quit\n",
            "👋 Goodbye!\n",
            "\n",
            "📚 MCP Tutorial Complete!\n",
            "\n",
            "🔍 What you learned:\n",
            "✅ How to implement MCP (Model Context Protocol) tools\n",
            "✅ Tool registration and discovery\n",
            "✅ Structured tool calling with arguments\n",
            "✅ Integration between MCP tools and Gemini AI\n",
            "✅ Async tool execution and response handling\n"
          ]
        }
      ]
    }
  ]
}